/*
 * MIT许可证
 *
 * 版权所有 (c) 2025-2035 JacobGreen
 *
 * 特此免费授予获得本软件及相关文档文件（"软件"）副本的任何人不受限制地处置该软件的权利，
 * 包括不限于使用、复制、修改、合并、发布、分发、再许可和/或出售该软件副本，
 * 以及允许被提供该软件的人这样做，须遵守以下条件：
 *
 * 上述版权声明和本许可声明应包含在该软件的所有副本或实质性部分中。
 *
 * 本软件按"原样"提供，不附带任何形式的明示或暗示的保证，
 * 包括但不限于对适销性、特定用途适用性和不侵权的保证。
 * 在任何情况下，作者或版权持有人均不对任何索赔、损害或其他
 * 责任负责，无论是在合同行为、侵权行为或其他方面，
 * 与软件或软件的使用或其他交易有关。
 */

#include "ArrayListTest.h"
#include "ArrayList.h"
#include "Log.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/**
 * 比较两个整数
 */
static int compareInt(void *a, void *b) {
    int *intA = (int *)a;
    int *intB = (int *)b;
    return (*intA) - (*intB);
}

/**
 * 辅助函数：从堆中分配整数内存
 */
static int *createInt(int value) {
    int *p = (int *)malloc(sizeof(int));
    if (p != NULL) {
        *p = value;
    }
    return p;
}

/**
 * 释放整数内存
 */
static void freeIntData(void *data) {
    if (data != NULL) {
        free(data);
    }
}

/**
 * 打印整数
 */
static void printInt(void *data) {
    if (data != NULL) {
        printf("%d ", *((int *)data));
    } else {
        printf("NULL ");
    }
}

/**
 * 分组函数：根据值的奇偶性分组
 */
static int groupByEvenOdd(void *data) {
    int value = *((int *)data);
    return value % 2; // 0表示偶数，1表示奇数
}

/**
 * 测试ArrayList初始化
 */
static bool testArrayListInit(void) {
    printf("测试ArrayList初始化...\n");
    LOG_INFO("数组表测试", "初始化", "测试ArrayList初始化...");
    
    // 测试默认容量初始化
    ArrayList *list = arrayListInit(10);
    if (list == NULL) {
        printf("[ERROR] ArrayList初始化失败\n");
        LOG_ERROR("数组表测试", "初始化", "ArrayList初始化失败");
        return false;
    }
    
    // 验证初始化参数
    bool success = true;
    if (list->size != 0) {
        printf("[ERROR] 初始size不为0: %d\n", list->size);
        LOG_ERROR("数组表测试", "初始化", "初始size不为0: %d", list->size);
        success = false;
    }
    
    if (list->capacity != 10) {
        printf("[ERROR] 初始capacity不为10: %d\n", list->capacity);
        LOG_ERROR("数组表测试", "初始化", "初始capacity不为10: %d", list->capacity);
        success = false;
    }
    
    if (list->data == NULL) {
        printf("[ERROR] data数组未分配内存\n");
        LOG_ERROR("数组表测试", "初始化", "data数组未分配内存");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList初始化 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "初始化", "测试ArrayList初始化 %s", success ? "通过" : "失败");
    return success;
}

// 数据操作

/**
 * 测试ArrayList的add函数
 */
static bool testArrayListAdd(void) {
    printf("测试ArrayList add函数...\n");
    LOG_INFO("数组表测试", "添加元素", "测试ArrayList add函数...");
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "添加元素", "创建测试数据失败");
        // 释放已分配的内存
        if (data1 != NULL) free(data1);
        if (data2 != NULL) free(data2);
        if (data3 != NULL) free(data3);
        return false;
    }
    
    // 创建ArrayList
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "添加元素", "创建ArrayList失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        return false;
    }
    
    // 测试添加第一个元素
    bool success = list->add(list, data1);
    if (!success || list->size != 1) {
        printf("[ERROR] 添加第一个元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "添加元素", "添加第一个元素失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        return false;
    }
    
    // 测试添加多个元素
    success = list->add(list, data2);
    if (!success || list->size != 2) {
        printf("[ERROR] 添加第二个元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "添加元素", "添加第二个元素失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        return false;
    }
    
    success = list->add(list, data3);
    if (!success || list->size != 3) {
        printf("[ERROR] 添加第三个元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "添加元素", "添加第三个元素失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        return false;
    }
    
    // 验证元素内容
    if (*((int *)list->data[0]) != 10 || *((int *)list->data[1]) != 20 || *((int *)list->data[2]) != 30) {
        printf("[ERROR] 元素内容验证失败\n");
        LOG_ERROR("数组表测试", "添加元素", "元素内容验证失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        return false;
    }
    
    // 测试扩容
    for (int i = 40; i <= 100; i += 10) {
        int *data = createInt(i);
        if (data == NULL) {
            printf("[ERROR] 创建扩容测试数据失败\n");
            LOG_ERROR("数组表测试", "添加元素", "创建扩容测试数据失败");
            arrayListDestroy(list);
            freeIntData(data1);
            freeIntData(data2);
            freeIntData(data3);
            return false;
        }
        
        success = list->add(list, data);
        if (!success) {
            printf("[ERROR] 扩容时添加元素失败，i=%d\n", i);
            LOG_ERROR("数组表测试", "添加元素", "扩容时添加元素失败，i=%d", i);
            freeIntData(data);
            arrayListDestroy(list);
            freeIntData(data1);
            freeIntData(data2);
            freeIntData(data3);
            return false;
        }
    }
    
    // 清理资源
    arrayListDestroy(list);
    
    printf("测试ArrayList add函数 通过\n");
    LOG_INFO("数组表测试", "添加元素", "测试ArrayList add函数 通过");
    return true;
}

/**
 * 测试ArrayList的remove函数
 */
static bool testArrayListRemove(void) {
    printf("测试ArrayList remove函数...\n");
    LOG_INFO("数组表测试", "删除指定元素", "测试ArrayList remove函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "删除指定元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "删除指定元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    bool success = true;
    
    // 测试删除存在的元素
    int targetValue = 20;
    success &= list->remove(list, &targetValue, compareInt);
    if (!success || list->size != 2) {
        printf("[ERROR] 删除存在的元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "删除指定元素", "删除存在的元素失败，size=%d", list->size);
        success = false;
    }
    
    // 验证元素内容和顺序
    if (*((int *)list->data[0]) != 10 || *((int *)list->data[1]) != 30) {
        printf("[ERROR] 删除元素后，元素内容或顺序不正确\n");
        LOG_ERROR("数组表测试", "删除指定元素", "删除元素后，元素内容或顺序不正确");
        success = false;
    }
    
    // 测试删除不存在的元素
    int nonExistentValue = 100;
    if (list->remove(list, &nonExistentValue, compareInt)) {
        printf("[ERROR] 删除不存在的元素应该返回false\n");
        LOG_ERROR("数组表测试", "删除指定元素", "删除不存在的元素应该返回false");
        success = false;
    }
    
    // 测试边界情况：空列表
    // 先清空列表
    while (list->size > 0) {
        int value = *((int *)list->data[0]);
        list->remove(list, &value, compareInt);
    }
    
    int value = 10;
    if (list->remove(list, &value, compareInt)) {
        printf("[ERROR] 空列表删除元素应该返回false\n");
        LOG_ERROR("数组表测试", "删除指定元素", "空列表删除元素应该返回false");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList remove函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "删除指定元素", "测试ArrayList remove函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的contains函数
 */
static bool testArrayListContains(void) {
    printf("测试ArrayList contains函数...\n");
    LOG_INFO("数组表测试", "包含元素", "测试ArrayList contains函数...");
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40); // 不在列表中的元素
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "包含元素", "创建测试数据失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "包含元素", "创建ArrayList失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 添加元素
    if (!list->add(list, data1) || !list->add(list, data2) || !list->add(list, data3)) {
        printf("[ERROR] 添加测试数据失败\n");
        LOG_ERROR("数组表测试", "包含元素", "添加测试数据失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    bool success = true;
    
    // 测试包含已存在的元素
    if (!list->contains(list, data1, compareInt)) {
        printf("[ERROR] 应该包含第一个元素\n");
        LOG_ERROR("数组表测试", "包含元素", "应该包含第一个元素");
        success = false;
    }
    
    if (!list->contains(list, data2, compareInt)) {
        printf("[ERROR] 应该包含第二个元素\n");
        LOG_ERROR("数组表测试", "包含元素", "应该包含第二个元素");
        success = false;
    }
    
    if (!list->contains(list, data3, compareInt)) {
        printf("[ERROR] 应该包含第三个元素\n");
        LOG_ERROR("数组表测试", "包含元素", "应该包含第三个元素");
        success = false;
    }
    
    // 测试不包含不存在的元素
    if (list->contains(list, data4, compareInt)) {
        printf("[ERROR] 不应该包含不存在的元素\n");
        LOG_ERROR("数组表测试", "包含元素", "不应该包含不存在的元素");
        success = false;
    }
    
    // 测试空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "包含元素", "创建空ArrayList失败");
        success = false;
    } else {
        if (emptyList->contains(emptyList, data1, compareInt)) {
            printf("[ERROR] 空列表不应该包含任何元素\n");
            LOG_ERROR("数组表测试", "包含元素", "空列表不应该包含任何元素");
            success = false;
        }
        arrayListDestroy(emptyList);
    }
    
    // 释放资源
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    freeIntData(data4);
    
    printf("测试ArrayList contains函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "包含元素", "测试ArrayList contains函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的contains函数
 */
static bool testArrayListIndexOf(void) {
    printf("测试ArrayList indexOf函数...\n");
    LOG_INFO("数组表测试", "获取首次索引", "测试ArrayList indexOf函数...");
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(20); // 与data2相等，用于测试重复元素
    int *data5 = createInt(40); // 不在列表中的元素
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || data5 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "获取首次索引", "创建测试数据失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取首次索引", "创建ArrayList失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 添加元素
    if (!list->add(list, data1) || !list->add(list, data2) || !list->add(list, data3) || !list->add(list, data4)) {
        printf("[ERROR] 添加测试数据失败\n");
        LOG_ERROR("数组表测试", "获取首次索引", "添加测试数据失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    bool success = true;
    
    // 测试查找首次出现的元素
    int index = list->indexOf(list, data1, compareInt);
    if (index != 0) {
        printf("[ERROR] 首次出现的元素索引应该是0，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取首次索引", "首次出现的元素索引测试失败");
        success = false;
    }
    
    // 测试查找重复元素的首次出现位置
    index = list->indexOf(list, data2, compareInt);
    if (index != 1) {
        printf("[ERROR] 重复元素的首次出现索引应该是1，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取首次索引", "重复元素的首次出现索引测试失败");
        success = false;
    }
    
    // 测试查找不存在的元素
    index = list->indexOf(list, data5, compareInt);
    if (index != -1) {
        printf("[ERROR] 不存在的元素索引应该是-1，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取首次索引", "不存在的元素索引测试失败");
        success = false;
    }
    
    // 测试空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取首次索引", "创建空ArrayList失败");
        success = false;
    } else {
        index = emptyList->indexOf(emptyList, data1, compareInt);
        if (index != -1) {
            printf("[ERROR] 空列表中元素索引应该是-1，实际是%d\n", index);
            LOG_ERROR("数组表测试", "获取首次索引", "空列表索引测试失败");
            success = false;
        }
        arrayListDestroy(emptyList);
    }
    
    // 测试NULL参数
    index = list->indexOf(list, NULL, compareInt);
    if (index != -1) {
        printf("[ERROR] NULL参数时索引应该是-1，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取首次索引", "NULL参数索引测试失败");
        success = false;
    }
    
    // 测试NULL比较函数
    index = list->indexOf(list, data1, NULL);
    if (index != -1) {
        printf("[ERROR] NULL比较函数时索引应该是-1，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取首次索引", "NULL比较函数索引测试失败");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    freeIntData(data4);
    freeIntData(data5);
    
    printf("测试ArrayList indexOf函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取首次索引", "测试ArrayList indexOf函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的lastIndexOf函数
 */
static bool testArrayListLastIndexOf(void) {
    printf("测试ArrayList lastIndexOf函数...\n");
    LOG_INFO("数组表测试", "获取最后索引", "测试ArrayList lastIndexOf函数...");
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(20); // 与data2相等，用于测试重复元素
    int *data5 = createInt(40); // 不在列表中的元素
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || data5 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "获取最后索引", "创建测试数据失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取最后索引", "创建ArrayList失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 添加元素
    if (!list->add(list, data1) || !list->add(list, data2) || !list->add(list, data3) || !list->add(list, data4)) {
        printf("[ERROR] 添加测试数据失败\n");
        LOG_ERROR("数组表测试", "获取最后索引", "添加测试数据失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    bool success = true;
    
    // 测试查找唯一元素的最后出现位置
    int index = list->lastIndexOf(list, data1, compareInt);
    if (index != 0) {
        printf("[ERROR] 唯一元素的最后出现索引应该是0，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取最后索引", "唯一元素的最后出现索引测试失败");
        success = false;
    }
    
    // 测试查找重复元素的最后出现位置
    index = list->lastIndexOf(list, data2, compareInt);
    if (index != 3) {
        printf("[ERROR] 重复元素的最后出现索引应该是3，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取最后索引", "重复元素的最后出现索引测试失败");
        success = false;
    }
    
    // 测试查找不存在的元素
    index = list->lastIndexOf(list, data5, compareInt);
    if (index != -1) {
        printf("[ERROR] 不存在的元素索引应该是-1，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取最后索引", "不存在的元素索引测试失败");
        success = false;
    }
    
    // 测试空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取最后索引", "创建空ArrayList失败");
        success = false;
    } else {
        index = emptyList->lastIndexOf(emptyList, data1, compareInt);
        if (index != -1) {
            printf("[ERROR] 空列表中元素索引应该是-1，实际是%d\n", index);
            LOG_ERROR("数组表测试", "获取最后索引", "空列表索引测试失败");
            success = false;
        }
        arrayListDestroy(emptyList);
    }
    
    // 测试NULL参数
    index = list->lastIndexOf(list, NULL, compareInt);
    if (index != -1) {
        printf("[ERROR] NULL参数时索引应该是-1，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取最后索引", "NULL参数索引测试失败");
        success = false;
    }
    
    // 测试NULL比较函数
    index = list->lastIndexOf(list, data1, NULL);
    if (index != -1) {
        printf("[ERROR] NULL比较函数时索引应该是-1，实际是%d\n", index);
        LOG_ERROR("数组表测试", "获取最后索引", "NULL比较函数索引测试失败");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    freeIntData(data4);
    freeIntData(data5);
    
    printf("测试ArrayList lastIndexOf函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取最后索引", "测试ArrayList lastIndexOf函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的replaceAll函数
 */
static bool testArrayListReplaceAll(void) {
    printf("测试ArrayList replaceAll函数...\n");
    LOG_INFO("数组表测试", "替换所有元素", "测试ArrayList replaceAll函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "替换所有元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(20); // 重复元素
    int *data4 = createInt(30);
    int *newValue = createInt(99); // 替换值
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || newValue == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "替换所有元素", "创建测试数据失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(newValue);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    list->add(list, data4);
    
    // 定义比较函数：判断元素是否等于20
    bool replaceCondition(void *element, void *newValue) {
        return *((int *)element) == 20;
    }
    
    // 执行替换操作
    list->replaceAll(list, newValue, replaceCondition);
    
    bool success = true;
    
    // 验证替换结果
    if (*((int *)list->data[0]) != 10) {
        printf("[ERROR] 第一个元素应该是10，实际是%d\n", *((int *)list->data[0]));
        LOG_ERROR("数组表测试", "替换所有元素", "第一个元素验证失败");
        success = false;
    }
    
    if (list->data[1] != newValue || list->data[2] != newValue) {
        printf("[ERROR] 应该被替换的元素没有被正确替换\n");
        LOG_ERROR("数组表测试", "替换所有元素", "替换元素验证失败");
        success = false;
    }
    
    if (*((int *)list->data[3]) != 30) {
        printf("[ERROR] 第四个元素应该是30，实际是%d\n", *((int *)list->data[3]));
        LOG_ERROR("数组表测试", "替换所有元素", "第四个元素验证失败");
        success = false;
    }
    
    // 测试空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "替换所有元素", "创建空ArrayList失败");
        success = false;
    } else {
        emptyList->replaceAll(emptyList, newValue, replaceCondition);
        // 空列表应该没有变化
        if (emptyList->size != 0) {
            printf("[ERROR] 空列表替换后大小应该为0\n");
            LOG_ERROR("数组表测试", "替换所有元素", "空列表替换测试失败");
            success = false;
        }
        arrayListDestroy(emptyList);
    }
    
    // 释放资源
    arrayListDestroy(list);
    freeIntData(data1);
    // data2和data3被替换了，不需要单独释放
    freeIntData(data4);
    freeIntData(newValue);
    
    printf("测试ArrayList replaceAll函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "替换所有元素", "测试ArrayList replaceAll函数 %s", success ? "通过" : "失败");
    return success;
}

// 索引操作

/**
 * 测试ArrayList的addIndex函数
 */
static bool testArrayListAddIndex(void) {
    printf("测试ArrayList addIndex函数...\n");
    LOG_INFO("数组表测试", "指定索引添加", "测试ArrayList addIndex函数...");
    
    // 创建ArrayList
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "指定索引添加", "创建ArrayList失败");
        return false;
    }
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "指定索引添加", "创建测试数据失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        arrayListDestroy(list);
        return false;
    }
    
    // 测试添加到末尾（等同于add）
    bool success = list->addIndex(list, 0, data1);
    if (!success || list->size != 1) {
        printf("[ERROR] 添加到索引0失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "指定索引添加", "添加到索引0失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 测试添加到中间位置
    success = list->addIndex(list, 1, data3);
    if (!success || list->size != 2) {
        printf("[ERROR] 添加到索引1失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "指定索引添加", "添加到索引1失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 测试添加到中间位置（插入到第一个位置）
    success = list->addIndex(list, 0, data4);
    if (!success || list->size != 3) {
        printf("[ERROR] 添加到索引0失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "指定索引添加", "添加到索引0失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 测试添加到中间位置
    success = list->addIndex(list, 2, data2);
    if (!success || list->size != 4) {
        printf("[ERROR] 添加到索引2失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "指定索引添加", "添加到索引2失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 验证元素顺序
    if (*((int *)list->data[0]) != 40 || *((int *)list->data[1]) != 10 || 
        *((int *)list->data[2]) != 20 || *((int *)list->data[3]) != 30) {
        printf("[ERROR] 元素顺序验证失败\n");
        LOG_ERROR("数组表测试", "指定索引添加", "元素顺序验证失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 测试无效索引
    success = list->addIndex(list, -1, data1);
    if (success) {
        printf("[ERROR] 添加到无效索引-1应该失败\n");
        LOG_ERROR("数组表测试", "指定索引添加", "添加到无效索引-1应该失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    success = list->addIndex(list, 10, data1);
    if (success) {
        printf("[ERROR] 添加到无效索引10应该失败\n");
        LOG_ERROR("数组表测试", "指定索引添加", "添加到无效索引10应该失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 清理资源
    arrayListDestroy(list);
    
    printf("测试ArrayList addIndex函数 通过\n");
    LOG_INFO("数组表测试", "指定索引添加", "测试ArrayList addIndex函数 通过");
    return true;
}

/**
 * 测试ArrayList的addFirst和addLast函数
 */
static bool testArrayListAddFirstAndAddLast(void) {
    printf("测试ArrayList addFirst和addLast函数...\n");
    LOG_INFO("数组表测试", "添加首元素和尾元素", "测试ArrayList addFirst和addLast函数...");
    
    // 创建ArrayList
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "创建ArrayList失败");
        return false;
    }
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "创建测试数据失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        arrayListDestroy(list);
        return false;
    }
    
    // 测试addLast函数（等同于add）
    bool success = list->addLast(list, data1);
    if (!success || list->size != 1) {
        printf("[ERROR] addLast函数测试失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "addLast函数测试失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 再添加一个元素到末尾
    success = list->addLast(list, data2);
    if (!success || list->size != 2) {
        printf("[ERROR] addLast函数再次测试失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "addLast函数再次测试失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 验证添加顺序（应该是10, 20）
    if (*((int *)list->data[0]) != 10 || *((int *)list->data[1]) != 20) {
        printf("[ERROR] addLast元素顺序验证失败\n");
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "addLast元素顺序验证失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 测试addFirst函数
    success = list->addFirst(list, data3);
    if (!success || list->size != 3) {
        printf("[ERROR] addFirst函数测试失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "addFirst函数测试失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 再次添加到开头
    success = list->addFirst(list, data4);
    if (!success || list->size != 4) {
        printf("[ERROR] addFirst函数再次测试失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "addFirst函数再次测试失败，size=%d", list->size);
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 验证最终顺序（应该是40, 30, 10, 20）
    if (*((int *)list->data[0]) != 40 || *((int *)list->data[1]) != 30 || 
        *((int *)list->data[2]) != 10 || *((int *)list->data[3]) != 20) {
        printf("[ERROR] 最终元素顺序验证失败\n");
        LOG_ERROR("数组表测试", "添加首元素和尾元素", "最终元素顺序验证失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    // 清理资源
    arrayListDestroy(list);
    
    printf("测试ArrayList addFirst和addLast函数 通过\n");
    LOG_INFO("数组表测试", "添加首元素和尾元素", "测试ArrayList addFirst和addLast函数 通过");
    return true;
}

/**
 * 测试ArrayList的removeIndex函数
 */
static bool testArrayListRemoveIndex(void) {
    printf("测试ArrayList removeIndex函数...\n");
    LOG_INFO("数组表测试", "删除指定索引元素", "测试ArrayList removeIndex函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "删除指定索引元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    int *data5 = createInt(50);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || data5 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "删除指定索引元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    list->add(list, data4);
    list->add(list, data5);
    
    bool success = true;
    
    // 测试删除中间元素
    void *removed = list->removeIndex(list, 2);
    if (removed == NULL || list->size != 4) {
        printf("[ERROR] 删除中间元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "删除指定索引元素", "删除中间元素失败，size=%d", list->size);
        success = false;
    }
    
    // 验证元素内容和顺序
    if (*((int *)list->data[0]) != 10 || *((int *)list->data[1]) != 20 || 
        *((int *)list->data[2]) != 40 || *((int *)list->data[3]) != 50) {
        printf("[ERROR] 删除中间元素后，元素内容或顺序不正确\n");
        LOG_ERROR("数组表测试", "删除指定索引元素", "删除中间元素后，元素内容或顺序不正确");
        success = false;
    }
    
    // 测试删除第一个元素
    removed = list->removeIndex(list, 0);
    if (removed == NULL || list->size != 3) {
        printf("[ERROR] 删除第一个元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "删除指定索引元素", "删除第一个元素失败，size=%d", list->size);
        success = false;
    }
    
    // 测试删除最后一个元素
    removed = list->removeIndex(list, 2);
    if (removed == NULL || list->size != 2) {
        printf("[ERROR] 删除最后一个元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "删除指定索引元素", "删除最后一个元素失败，size=%d", list->size);
        success = false;
    }
    
    // 测试边界情况：索引越界
    if (list->removeIndex(list, 10) != NULL) {
        printf("[ERROR] 索引越界应该返回false\n");
        LOG_ERROR("数组表测试", "删除指定索引元素", "索引越界应该返回false");
        success = false;
    }
    
    // 测试边界情况：负数索引
    if (list->removeIndex(list, -1) != NULL) {
        printf("[ERROR] 负数索引应该返回false\n");
        LOG_ERROR("数组表测试", "删除指定索引元素", "负数索引应该返回false");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList removeIndex函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "删除指定索引元素", "测试ArrayList removeIndex函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的removeFirst函数
 */
static bool testArrayListRemoveFirst(void) {
    printf("测试ArrayList removeFirst函数...\n");
    LOG_INFO("数组表测试", "删除第一个元素", "测试ArrayList removeFirst函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "删除第一个元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "删除第一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    bool success = true;
    
    // 测试删除第一个元素
    void *removed = list->removeFirst(list);
    if (removed == NULL || list->size != 2) {
        printf("[ERROR] 删除第一个元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "删除第一个元素", "删除第一个元素失败，size=%d", list->size);
        success = false;
    }
    
    // 验证元素内容和顺序
    if (*((int *)list->data[0]) != 20 || *((int *)list->data[1]) != 30) {
        printf("[ERROR] 删除第一个元素后，元素内容或顺序不正确\n");
        LOG_ERROR("数组表测试", "删除第一个元素", "删除第一个元素后，元素内容或顺序不正确");
        success = false;
    }
    
    // 测试边界情况：空列表
    // 先清空列表
    while (list->size > 0) {
        list->removeFirst(list);
    }
    
    if (list->removeFirst(list) != NULL) {
        printf("[ERROR] 空列表删除第一个元素应该返回false\n");
        LOG_ERROR("数组表测试", "删除第一个元素", "空列表删除第一个元素应该返回false");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList removeFirst函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "删除第一个元素", "测试ArrayList removeFirst函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的removeLast函数
 */
static bool testArrayListRemoveLast(void) {
    printf("测试ArrayList removeLast函数...\n");
    LOG_INFO("数组表测试", "删除最后一个元素", "测试ArrayList removeLast函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "删除最后一个元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "删除最后一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    bool success = true;
    
    // 测试删除最后一个元素
    void *removed = list->removeLast(list);
    if (removed == NULL || list->size != 2) {
        printf("[ERROR] 删除最后一个元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "删除最后一个元素", "删除最后一个元素失败，size=%d", list->size);
        success = false;
    }
    
    // 验证元素内容和顺序
    if (*((int *)list->data[0]) != 10 || *((int *)list->data[1]) != 20) {
        printf("[ERROR] 删除最后一个元素后，元素内容或顺序不正确\n");
        LOG_ERROR("数组表测试", "删除最后一个元素", "删除最后一个元素后，元素内容或顺序不正确");
        success = false;
    }
    
    // 测试边界情况：空列表
    // 先清空列表
    while (list->size > 0) {
        list->removeLast(list);
    }
    
    if (list->removeLast(list) != NULL) {
        printf("[ERROR] 空列表删除最后一个元素应该返回false\n");
        LOG_ERROR("数组表测试", "删除最后一个元素", "空列表删除最后一个元素应该返回false");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList removeLast函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "删除最后一个元素", "测试ArrayList removeLast函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的set函数
 */
static bool testArrayListSet(void) {
    printf("测试ArrayList set函数...\n");
    LOG_INFO("数组表测试", "设置元素", "测试ArrayList set函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "设置元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "设置元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    bool success = true;
    
    // 测试正常替换元素
    int *newData = createInt(100);
    if (newData == NULL) {
        printf("[ERROR] 创建替换元素失败\n");
        LOG_ERROR("数组表测试", "设置元素", "创建替换元素失败");
        arrayListDestroy(list);
        return false;
    }
    
    void *oldData = list->set(list, 1, newData);
    if (oldData == NULL || list->size != 3 || *((int *)oldData) != 20 || *((int *)list->data[1]) != 100) {
        printf("[ERROR] 替换元素失败，size=%d, oldData=%d, newData=%d\n", 
               list->size, oldData ? *((int *)oldData) : -1, *((int *)list->data[1]));
        LOG_ERROR("数组表测试", "设置元素", "替换元素失败");
        success = false;
    }
    
    // 释放旧元素
    freeIntData(oldData);
    
    // 测试边界情况：索引越界
    int *anotherData = createInt(200);
    if (anotherData == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "设置元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    if (list->set(list, 5, anotherData) != NULL) {
        printf("[ERROR] 索引越界应该返回NULL\n");
        LOG_ERROR("数组表测试", "设置元素", "索引越界应该返回NULL");
        success = false;
    }
    freeIntData(anotherData);
    
    // 测试边界情况：负数索引
    if (list->set(list, -1, anotherData) != NULL) {
        printf("[ERROR] 负数索引应该返回NULL\n");
        LOG_ERROR("数组表测试", "设置元素", "负数索引应该返回NULL");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList set函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "设置元素", "测试ArrayList set函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的setFirst函数
 */
static bool testArrayListSetFirst(void) {
    printf("测试ArrayList setFirst函数...\n");
    LOG_INFO("数组表测试", "设置第一个元素", "测试ArrayList setFirst函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "设置第一个元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    
    if (data1 == NULL || data2 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "设置第一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    
    bool success = true;
    
    // 测试正常替换第一个元素
    int *newData = createInt(100);
    if (newData == NULL) {
        printf("[ERROR] 创建替换元素失败\n");
        LOG_ERROR("数组表测试", "设置第一个元素", "创建替换元素失败");
        arrayListDestroy(list);
        return false;
    }
    
    void *oldData = list->setFirst(list, newData);
    if (oldData == NULL || list->size != 2 || *((int *)oldData) != 10 || *((int *)list->data[0]) != 100) {
        printf("[ERROR] 替换第一个元素失败，size=%d, oldData=%d, newData=%d\n", 
               list->size, oldData ? *((int *)oldData) : -1, *((int *)list->data[0]));
        LOG_ERROR("数组表测试", "设置第一个元素", "替换第一个元素失败");
        success = false;
    }
    
    // 释放旧元素
    freeIntData(oldData);
    
    // 测试边界情况：空列表
    ArrayList *emptyList = arrayListInit(5);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "设置第一个元素", "创建空ArrayList失败");
        arrayListDestroy(list);
        return false;
    }
    
    int *testData = createInt(200);
    if (testData == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "设置第一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        arrayListDestroy(emptyList);
        return false;
    }
    
    if (emptyList->setFirst(emptyList, testData) != NULL) {
        printf("[ERROR] 空列表设置第一个元素应该返回NULL\n");
        LOG_ERROR("数组表测试", "设置第一个元素", "空列表设置第一个元素应该返回NULL");
        success = false;
    }
    freeIntData(testData);
    
    // 释放资源
    arrayListDestroy(list);
    arrayListDestroy(emptyList);
    
    printf("测试ArrayList setFirst函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "设置第一个元素", "测试ArrayList setFirst函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的setLast函数
 */
static bool testArrayListSetLast(void) {
    printf("测试ArrayList setLast函数...\n");
    LOG_INFO("数组表测试", "设置最后一个元素", "测试ArrayList setLast函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "设置最后一个元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    
    if (data1 == NULL || data2 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "设置最后一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    
    bool success = true;
    
    // 测试正常替换最后一个元素
    int *newData = createInt(100);
    if (newData == NULL) {
        printf("[ERROR] 创建替换元素失败\n");
        LOG_ERROR("数组表测试", "设置最后一个元素", "创建替换元素失败");
        arrayListDestroy(list);
        return false;
    }
    
    void *oldData = list->setLast(list, newData);
    if (oldData == NULL || list->size != 2 || *((int *)oldData) != 20 || *((int *)list->data[1]) != 100) {
        printf("[ERROR] 替换最后一个元素失败，size=%d, oldData=%d, newData=%d\n", 
               list->size, oldData ? *((int *)oldData) : -1, *((int *)list->data[1]));
        LOG_ERROR("数组表测试", "设置最后一个元素", "替换最后一个元素失败");
        success = false;
    }
    
    // 释放旧元素
    freeIntData(oldData);
    
    // 测试边界情况：空列表
    ArrayList *emptyList = arrayListInit(5);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "设置最后一个元素", "创建空ArrayList失败");
        arrayListDestroy(list);
        return false;
    }
    
    int *testData = createInt(200);
    if (testData == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "设置最后一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        arrayListDestroy(emptyList);
        return false;
    }
    
    if (emptyList->setLast(emptyList, testData) != NULL) {
        printf("[ERROR] 空列表设置最后一个元素应该返回NULL\n");
        LOG_ERROR("数组表测试", "设置最后一个元素", "空列表设置最后一个元素应该返回NULL");
        success = false;
    }
    freeIntData(testData);
    
    // 释放资源
    arrayListDestroy(list);
    arrayListDestroy(emptyList);
    
    printf("测试ArrayList setLast函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "设置最后一个元素", "测试ArrayList setLast函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的get函数
 */
static bool testArrayListGet(void) {
    printf("测试ArrayList get函数...\n");
    LOG_INFO("数组表测试", "获取元素", "测试ArrayList get函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "获取元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    bool success = true;
    
    // 测试正常获取元素
    void *element = list->get(list, 1);
    if (element == NULL || *((int *)element) != 20) {
        printf("[ERROR] 获取元素失败，获取值：%d，期望值：20\n", element ? *((int *)element) : -1);
        LOG_ERROR("数组表测试", "获取元素", "获取元素失败");
        success = false;
    }
    
    // 测试边界情况：索引0
    element = list->get(list, 0);
    if (element == NULL || *((int *)element) != 10) {
        printf("[ERROR] 获取索引0元素失败，获取值：%d，期望值：10\n", element ? *((int *)element) : -1);
        LOG_ERROR("数组表测试", "获取元素", "获取索引0元素失败");
        success = false;
    }
    
    // 测试边界情况：最后一个元素索引
    element = list->get(list, 2);
    if (element == NULL || *((int *)element) != 30) {
        printf("[ERROR] 获取最后一个元素失败，获取值：%d，期望值：30\n", element ? *((int *)element) : -1);
        LOG_ERROR("数组表测试", "获取元素", "获取最后一个元素失败");
        success = false;
    }
    
    // 测试边界情况：索引越界
    if (list->get(list, 5) != NULL) {
        printf("[ERROR] 索引越界应该返回NULL\n");
        LOG_ERROR("数组表测试", "获取元素", "索引越界应该返回NULL");
        success = false;
    }
    
    // 测试边界情况：负数索引
    if (list->get(list, -1) != NULL) {
        printf("[ERROR] 负数索引应该返回NULL\n");
        LOG_ERROR("数组表测试", "获取元素", "负数索引应该返回NULL");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList get函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取元素", "测试ArrayList get函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的getFirst函数
 */
static bool testArrayListGetFirst(void) {
    printf("测试ArrayList getFirst函数...\n");
    LOG_INFO("数组表测试", "获取第一个元素", "测试ArrayList getFirst函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取第一个元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    
    if (data1 == NULL || data2 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "获取第一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    
    bool success = true;
    
    // 测试正常获取第一个元素
    void *element = list->getFirst(list);
    if (element == NULL || *((int *)element) != 10) {
        printf("[ERROR] 获取第一个元素失败，获取值：%d，期望值：10\n", element ? *((int *)element) : -1);
        LOG_ERROR("数组表测试", "获取第一个元素", "获取第一个元素失败");
        success = false;
    }
    
    // 测试边界情况：空列表
    ArrayList *emptyList = arrayListInit(5);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取第一个元素", "创建空ArrayList失败");
        arrayListDestroy(list);
        return false;
    }
    
    if (emptyList->getFirst(emptyList) != NULL) {
        printf("[ERROR] 空列表获取第一个元素应该返回NULL\n");
        LOG_ERROR("数组表测试", "获取第一个元素", "空列表获取第一个元素应该返回NULL");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    arrayListDestroy(emptyList);
    
    printf("测试ArrayList getFirst函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取第一个元素", "测试ArrayList getFirst函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的getLast函数
 */
static bool testArrayListGetLast(void) {
    printf("测试ArrayList getLast函数...\n");
    LOG_INFO("数组表测试", "获取最后一个元素", "测试ArrayList getLast函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取最后一个元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    
    if (data1 == NULL || data2 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "获取最后一个元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    
    bool success = true;
    
    // 测试正常获取最后一个元素
    void *element = list->getLast(list);
    if (element == NULL || *((int *)element) != 20) {
        printf("[ERROR] 获取最后一个元素失败，获取值：%d，期望值：20\n", element ? *((int *)element) : -1);
        LOG_ERROR("数组表测试", "获取最后一个元素", "获取最后一个元素失败");
        success = false;
    }
    
    // 测试边界情况：空列表
    ArrayList *emptyList = arrayListInit(5);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "获取最后一个元素", "创建空ArrayList失败");
        arrayListDestroy(list);
        return false;
    }
    
    if (emptyList->getLast(emptyList) != NULL) {
        printf("[ERROR] 空列表获取最后一个元素应该返回NULL\n");
        LOG_ERROR("数组表测试", "获取最后一个元素", "空列表获取最后一个元素应该返回NULL");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    arrayListDestroy(emptyList);
    
    printf("测试ArrayList getLast函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取最后一个元素", "测试ArrayList getLast函数 %s", success ? "通过" : "失败");
    return success;
}

// 集合操作

/**
 * 测试ArrayList的addAll函数
 */
static bool testArrayListAddAll(void) {
    printf("测试ArrayList addAll函数...\n");
    LOG_INFO("数组表测试", "添加列表元素", "测试ArrayList addAll函数...");
    
    // 创建目标ArrayList
    ArrayList *targetList = arrayListInit(5);
    if (targetList == NULL) {
        printf("[ERROR] 创建targetList失败\n");
        LOG_ERROR("数组表测试", "添加列表元素", "创建targetList失败");
        return false;
    }
    
    // 创建源ArrayList
    ArrayList *sourceList = arrayListInit(5);
    if (sourceList == NULL) {
        printf("[ERROR] 创建sourceList失败\n");
        LOG_ERROR("数组表测试", "添加列表元素", "创建sourceList失败");
        arrayListDestroy(targetList);
        return false;
    }
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    int *data5 = createInt(50);
    int *data6 = createInt(60);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || 
        data4 == NULL || data5 == NULL || data6 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "添加列表元素", "创建测试数据失败");
        // 释放已分配的内存
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data6);
        arrayListDestroy(targetList);
        arrayListDestroy(sourceList);
        return false;
    }
    
    // 向目标列表添加初始元素
    if (!targetList->add(targetList, data1) || !targetList->add(targetList, data2)) {
        printf("[ERROR] 向targetList添加初始元素失败\n");
        LOG_ERROR("数组表测试", "添加列表元素", "向targetList添加初始元素失败");
        arrayListDestroy(targetList);
        arrayListDestroy(sourceList);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data6);
        return false;
    }
    
    // 向源列表添加元素
    if (!sourceList->add(sourceList, data3) || !sourceList->add(sourceList, data4) || 
        !sourceList->add(sourceList, data5)) {
        printf("[ERROR] 向sourceList添加元素失败\n");
        LOG_ERROR("数组表测试", "添加列表元素", "向sourceList添加元素失败");
        arrayListDestroy(targetList);
        arrayListDestroy(sourceList);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data6);
        return false;
    }
    
    // 测试从空列表添加（不会改变目标列表）
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建emptyList失败\n");
        LOG_ERROR("数组表测试", "添加列表元素", "创建emptyList失败");
        arrayListDestroy(targetList);
        arrayListDestroy(sourceList);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data6);
        return false;
    }
    
    bool success = targetList->addAll(targetList, emptyList);
    if (!success || targetList->size != 2) {
        printf("[ERROR] 从空列表添加后目标列表size错误，expected=2, actual=%d\n", targetList->size);
        LOG_ERROR("数组表测试", "添加列表元素", "从空列表添加后目标列表size错误，expected=2, actual=%d", targetList->size);
        arrayListDestroy(targetList);
        arrayListDestroy(sourceList);
        arrayListDestroy(emptyList);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data6);
        return false;
    }
    
    // 测试从源列表添加所有元素
    success = targetList->addAll(targetList, sourceList);
    if (!success || targetList->size != 5) {
        printf("[ERROR] 添加所有元素后目标列表size错误，expected=5, actual=%d\n", targetList->size);
        LOG_ERROR("数组表测试", "添加列表元素", "添加所有元素后目标列表size错误，expected=5, actual=%d", targetList->size);
        arrayListDestroy(targetList);
        arrayListDestroy(sourceList);
        arrayListDestroy(emptyList);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data6);
        return false;
    }
    
    // 验证元素顺序
    if (*((int *)targetList->data[0]) != 10 || *((int *)targetList->data[1]) != 20 || 
        *((int *)targetList->data[2]) != 30 || *((int *)targetList->data[3]) != 40 || 
        *((int *)targetList->data[4]) != 50) {
        printf("[ERROR] 元素顺序验证失败\n");
        LOG_ERROR("数组表测试", "添加列表元素", "元素顺序验证失败");
        arrayListDestroy(targetList);
        arrayListDestroy(sourceList);
        arrayListDestroy(emptyList);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data6);
        return false;
    }
    
    // 清理资源
    arrayListDestroy(emptyList);
    arrayListDestroy(sourceList);
    arrayListDestroy(targetList);
    freeIntData(data6); // 这个数据没有被添加到任何列表中
    
    printf("测试ArrayList addAll函数 通过\n");
    LOG_INFO("数组表测试", "添加列表元素", "测试ArrayList addAll函数 通过");
    return true;
}

/**
 * 测试ArrayList的removeAll函数
 */
static bool testArrayListRemoveAll(void) {
    printf("测试ArrayList removeAll函数...\n");
    LOG_INFO("数组表测试", "移除列表元素", "测试ArrayList removeAll函数...");
    
    // 创建两个ArrayList
    ArrayList *list1 = arrayListInit(5);
    ArrayList *list2 = arrayListInit(5);
    
    if (list1 == NULL || list2 == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "移除列表元素", "创建ArrayList失败");
        if (list1 != NULL) arrayListDestroy(list1);
        if (list2 != NULL) arrayListDestroy(list2);
        return false;
    }
    
    // 向list1添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    int *data5 = createInt(50);
    
    // 向list2添加测试数据（部分与list1相同）
    int *data2_1 = createInt(20);
    int *data2_2 = createInt(30);
    int *data2_3 = createInt(60);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || data5 == NULL ||
        data2_1 == NULL || data2_2 == NULL || data2_3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "移除列表元素", "创建测试数据失败");
        // 释放已分配的内存
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data2_1);
        freeIntData(data2_2);
        freeIntData(data2_3);
        arrayListDestroy(list1);
        arrayListDestroy(list2);
        return false;
    }
    
    list1->add(list1, data1);
    list1->add(list1, data2);
    list1->add(list1, data3);
    list1->add(list1, data4);
    list1->add(list1, data5);
    
    list2->add(list2, data2_1);
    list2->add(list2, data2_2);
    list2->add(list2, data2_3);
    
    bool success = true;
    
    // 测试移除与list2相同的元素
    success &= list1->removeAll(list1, list2, compareInt);
    if (!success || list1->size != 3) {
        printf("[ERROR] removeAll失败，size=%d\n", list1->size);
        LOG_ERROR("数组表测试", "移除列表元素", "removeAll失败，size=%d", list1->size);
        success = false;
    }
    
    // 验证list1中只剩下10,40,50
    bool found10 = false, found40 = false, found50 = false;
    for (int i = 0; i < list1->size; i++) {
        int value = *((int *)list1->data[i]);
        if (value == 10) found10 = true;
        else if (value == 40) found40 = true;
        else if (value == 50) found50 = true;
    }
    
    if (!found10 || !found40 || !found50) {
        printf("[ERROR] removeAll后，元素内容不正确\n");
        LOG_ERROR("数组表测试", "移除列表元素", "removeAll后，元素内容不正确");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list1);
    arrayListDestroy(list2);
    
    printf("测试ArrayList removeAll函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "移除列表元素", "测试ArrayList removeAll函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的retainAll函数
 */
static bool testArrayListRetainAll(void) {
    printf("测试ArrayList retainAll函数...\n");
    LOG_INFO("数组表测试", "保留列表元素", "测试ArrayList retainAll函数...");
    
    // 创建两个ArrayList
    ArrayList *list1 = arrayListInit(5);
    ArrayList *list2 = arrayListInit(5);
    
    if (list1 == NULL || list2 == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "保留列表元素", "创建ArrayList失败");
        if (list1 != NULL) arrayListDestroy(list1);
        if (list2 != NULL) arrayListDestroy(list2);
        return false;
    }
    
    // 向list1添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    int *data5 = createInt(50);
    
    // 向list2添加测试数据（部分与list1相同）
    int *data2_1 = createInt(20);
    int *data2_2 = createInt(30);
    int *data2_3 = createInt(60);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || data5 == NULL ||
        data2_1 == NULL || data2_2 == NULL || data2_3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "保留列表元素", "创建测试数据失败");
        // 释放已分配的内存
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        freeIntData(data2_1);
        freeIntData(data2_2);
        freeIntData(data2_3);
        arrayListDestroy(list1);
        arrayListDestroy(list2);
        return false;
    }
    
    list1->add(list1, data1);
    list1->add(list1, data2);
    list1->add(list1, data3);
    list1->add(list1, data4);
    list1->add(list1, data5);
    
    list2->add(list2, data2_1);
    list2->add(list2, data2_2);
    list2->add(list2, data2_3);
    
    bool success = true;
    
    // 测试保留与list2相同的元素
    success &= list1->retainAll(list1, list2, compareInt);
    if (!success || list1->size != 2) {
        printf("[ERROR] retainAll失败，size=%d\n", list1->size);
        LOG_ERROR("数组表测试", "保留列表元素", "retainAll失败，size=%d", list1->size);
        success = false;
    }
    
    // 验证list1中只剩下20和30
    bool found20 = false, found30 = false;
    for (int i = 0; i < list1->size; i++) {
        int value = *((int *)list1->data[i]);
        if (value == 20) found20 = true;
        else if (value == 30) found30 = true;
    }
    
    if (!found20 || !found30) {
        printf("[ERROR] retainAll后，元素内容不正确\n");
        LOG_ERROR("数组表测试", "保留列表元素", "retainAll后，元素内容不正确");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list1);
    arrayListDestroy(list2);
    
    printf("测试ArrayList retainAll函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "保留列表元素", "测试ArrayList retainAll函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的containsAll函数
 */
static bool testArrayListContainsAll(void) {
    printf("测试ArrayList containsAll函数...\n");
    LOG_INFO("数组表测试", "包含所有元素", "测试ArrayList containsAll函数...");
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    int *data5 = createInt(50); // 不在主列表中的元素
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || data5 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "创建测试数据失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 创建主列表并添加元素
    ArrayList *list1 = arrayListInit(10);
    if (list1 == NULL) {
        printf("[ERROR] 创建主ArrayList失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "创建主ArrayList失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 添加元素到主列表
    if (!list1->add(list1, data1) || !list1->add(list1, data2) || !list1->add(list1, data3) || !list1->add(list1, data4)) {
        printf("[ERROR] 向主列表添加元素失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "向主列表添加元素失败");
        arrayListDestroy(list1);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 创建子列表（所有元素都在主列表中）
    ArrayList *list2 = arrayListInit(5);
    if (list2 == NULL) {
        printf("[ERROR] 创建子ArrayList失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "创建子ArrayList失败");
        arrayListDestroy(list1);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 添加元素到子列表（注意：这里只传递指针，不拥有内存）
    if (!list2->add(list2, data2) || !list2->add(list2, data3)) {
        printf("[ERROR] 向子列表添加元素失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "向子列表添加元素失败");
        arrayListDestroy(list1);
        arrayListDestroy(list2);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 创建不匹配列表（包含不在主列表中的元素）
    ArrayList *list3 = arrayListInit(5);
    if (list3 == NULL) {
        printf("[ERROR] 创建不匹配ArrayList失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "创建不匹配ArrayList失败");
        arrayListDestroy(list1);
        arrayListDestroy(list2);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 添加元素到不匹配列表
    if (!list3->add(list3, data2) || !list3->add(list3, data5)) {
        printf("[ERROR] 向不匹配列表添加元素失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "向不匹配列表添加元素失败");
        arrayListDestroy(list1);
        arrayListDestroy(list2);
        arrayListDestroy(list3);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    // 创建空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "包含所有元素", "创建空ArrayList失败");
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        freeIntData(data5);
        return false;
    }
    
    bool success = true;
    
    // 测试主列表包含子列表的所有元素
    if (!list1->containsAll(list1, list2, compareInt)) {
        printf("[ERROR] 主列表应该包含子列表的所有元素\n");
        LOG_ERROR("数组表测试", "包含所有元素", "主列表应该包含子列表的所有元素");
        success = false;
    }
    
    // 测试主列表不包含不匹配列表的所有元素
    if (list1->containsAll(list1, list3, compareInt)) {
        printf("[ERROR] 主列表不应该包含不匹配列表的所有元素\n");
        LOG_ERROR("数组表测试", "包含所有元素", "主列表不应该包含不匹配列表的所有元素");
        success = false;
    }
    
    // 测试任何列表都包含空列表的所有元素
    if (!list1->containsAll(list1, emptyList, compareInt)) {
        printf("[ERROR] 任何列表都应该包含空列表的所有元素\n");
        LOG_ERROR("数组表测试", "包含所有元素", "任何列表都应该包含空列表的所有元素");
        success = false;
    }
    
    // 测试空列表不包含非空列表的所有元素
    if (emptyList->containsAll(emptyList, list2, compareInt)) {
        printf("[ERROR] 空列表不应该包含非空列表的所有元素\n");
        LOG_ERROR("数组表测试", "包含所有元素", "空列表不应该包含非空列表的所有元素");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list1);
    arrayListDestroy(list2);
    arrayListDestroy(list3);
    arrayListDestroy(emptyList);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    freeIntData(data4);
    freeIntData(data5);
    
    printf("测试ArrayList containsAll函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "包含所有元素", "测试ArrayList containsAll函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList merge函数
 */
static bool testArrayListMerge(void) {
    printf("测试ArrayList merge函数...\n");
    LOG_INFO("数组表测试", "合并数组表", "测试ArrayList merge函数...");
    
    bool success = true;
    
    // 创建源数组表
    ArrayList *sourceList = arrayListInit(5);
    int *s1 = createInt(100);
    int *s2 = createInt(200);
    sourceList->add(sourceList, s1);
    sourceList->add(sourceList, s2);
    
    // 创建目标数组表
    ArrayList *targetList = arrayListInit(5);
    int *t1 = createInt(10);
    int *t2 = createInt(20);
    targetList->add(targetList, t1);
    targetList->add(targetList, t2);
    
    // 测试合并操作
    bool result = targetList->merge(targetList, sourceList);
    if (!result || targetList->size != 4) {
        printf("[ERROR] 合并操作失败，size=%d\n", targetList->size);
        LOG_ERROR("数组表测试", "合并数组表", "合并操作失败，size=%d", targetList->size);
        success = false;
    }
    
    // 验证元素顺序
    if (*((int *)targetList->data[0]) != 10 || 
        *((int *)targetList->data[1]) != 20 || 
        *((int *)targetList->data[2]) != 100 || 
        *((int *)targetList->data[3]) != 200) {
        printf("[ERROR] 合并后元素顺序验证失败\n");
        LOG_ERROR("数组表测试", "合并数组表", "合并后元素顺序验证失败");
        success = false;
    }
    
    // 测试空数组表合并
    ArrayList *emptyList = arrayListInit(0);
    result = targetList->merge(targetList, emptyList);
    if (!result || targetList->size != 4) {
        printf("[ERROR] 合并空数组表失败，size=%d\n", targetList->size);
        LOG_ERROR("数组表测试", "合并数组表", "合并空数组表失败，size=%d", targetList->size);
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(sourceList);
    arrayListDestroy(targetList);
    arrayListDestroy(emptyList);
    
    printf("测试ArrayList merge函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "合并数组表", "测试ArrayList merge函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList equals函数
 */
static bool testArrayListEquals(void) {
    printf("测试ArrayList equals函数...\n");
    LOG_INFO("数组表测试", "比较相等", "测试ArrayList equals函数...");
    
    bool success = true;
    
    // 创建两个内容相同的数组表
    ArrayList *list1 = arrayListInit(5);
    ArrayList *list2 = arrayListInit(5);
    
    // 添加相同的元素（注意：这里直接比较指针，所以使用相同的指针值）
    for (int i = 1; i <= 5; i++) {
        int *data = createInt(i * 10);
        list1->add(list1, data);
        // 为了测试，我们创建相同值的新指针，但不是同一个指针
        int *data2 = createInt(i * 10);
        list2->add(list2, data2);
    }
    
    // 测试内容相同但不是同一个对象的情况
    bool result = list1->equals(list1, list2, compareInt);
    if (!result) {
        printf("[ERROR] 内容相同但指针不同的结果比较失败");
        LOG_ERROR("数组表测试", "比较相等", "内容相同但指针不同的结果比较失败");
        success &= false;
    }
    
    // 测试相同对象的情况（地址相等）
    result = list1->equals(list1, list1, compareInt);
    if (!result) {
        printf("[ERROR] 相同对象比较失败\n");
        LOG_ERROR("数组表测试", "比较相等", "相同对象比较失败");
        success &= false;
    }
    
    // 创建一个内容不同的数组表
    ArrayList *list3 = arrayListInit(5);
    for (int i = 1; i <= 5; i++) {
        int *data = createInt(i * 100);
        list3->add(list3, data);
    }
    
    // 测试内容不同的情况
    result = list1->equals(list1, list3, compareInt);
    if (result) {
        printf("[ERROR] 不同内容比较失败\n");
        LOG_ERROR("数组表测试", "比较相等", "不同内容比较失败");
        success &= false;
    }
    
    // 测试大小不同的情况
    list1->add(list1, createInt(60));
    result = list1->equals(list1, list2, compareInt);
    if (result) {
        printf("[ERROR] 不同大小比较失败\n");
        LOG_ERROR("数组表测试", "比较相等", "不同大小比较失败");
        success &= false;
    }
    
    // 释放资源
    arrayListDestroy(list1);
    arrayListDestroy(list2);
    arrayListDestroy(list3);
    
    printf("测试ArrayList equals函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "比较相等", "测试ArrayList equals函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList clone函数
 */
static bool testArrayListClone(void) {
    printf("测试ArrayList clone函数...\n");
    LOG_INFO("数组表测试", "克隆数组表", "测试ArrayList clone函数...");
    
    bool success = true;
    
    // 创建源数组表
    ArrayList *sourceList = arrayListInit(5);
    int *s1 = createInt(10);
    int *s2 = createInt(20);
    int *s3 = createInt(30);
    sourceList->add(sourceList, s1);
    sourceList->add(sourceList, s2);
    sourceList->add(sourceList, s3);
    
    // 测试克隆操作
    ArrayList *cloneList = sourceList->clone(sourceList);
    if (cloneList == NULL) {
        printf("[ERROR] 克隆操作失败\n");
        LOG_ERROR("数组表测试", "克隆数组表", "克隆操作失败");
        success = false;
    } else {
        // 验证克隆的大小
        if (cloneList->size != 3) {
            printf("[ERROR] 克隆后的大小错误，期望值: 3, 实际值: %d\n", cloneList->size);
            LOG_ERROR("数组表测试", "克隆数组表", "克隆后的大小错误，期望值: 3, 实际值: %d", cloneList->size);
            success = false;
        }
        
        // 验证元素内容
        if (*((int *)cloneList->data[0]) != 10 || 
            *((int *)cloneList->data[1]) != 20 || 
            *((int *)cloneList->data[2]) != 30) {
            printf("[ERROR] 克隆后的元素内容验证失败\n");
            LOG_ERROR("数组表测试", "克隆数组表", "克隆后的元素内容验证失败");
            success = false;
        }
        
        // 验证是不同的对象
        if (sourceList == cloneList) {
            printf("[ERROR] 克隆返回了同一个对象\n");
            LOG_ERROR("数组表测试", "克隆数组表", "克隆返回了同一个对象");
            success = false;
        }
        
        // 释放克隆的数组表
        arrayListDestroy(cloneList);
    }
    
    // 释放源数组表
    arrayListDestroy(sourceList);
    
    printf("测试ArrayList clone函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "克隆数组表", "测试ArrayList clone函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList subList函数
 */
static bool testArrayListSubList(void) {
    printf("测试ArrayList subList函数...\n");
    LOG_INFO("数组表测试", "获取子列表", "测试ArrayList subList函数...");
    
    bool success = true;
    
    // 创建源数组表
    ArrayList *sourceList = arrayListInit(10);
    for (int i = 1; i <= 10; i++) {
        int *data = createInt(i * 10);
        sourceList->add(sourceList, data);
    }
    
    // 测试正常范围的子列表
    ArrayList *subList = sourceList->subList(sourceList, 2, 7);
    if (subList == NULL) {
        printf("[ERROR] 获取子列表失败\n");
        LOG_ERROR("数组表测试", "获取子列表", "获取子列表失败");
        success = false;
    } else {
        // 验证子列表大小
        if (subList->size != 5) {
            printf("[ERROR] 子列表大小错误，期望值: 5, 实际值: %d\n", subList->size);
            LOG_ERROR("数组表测试", "获取子列表", "子列表大小错误，期望值: 5, 实际值: %d", subList->size);
            success = false;
        }
        
        // 验证子列表元素
        for (int i = 0; i < 5; i++) {
            if (*((int *)subList->data[i]) != (i + 3) * 10) {
                printf("[ERROR] 子列表元素验证失败，索引%d，期望值: %d, 实际值: %d\n", 
                       i, (i + 3) * 10, *((int *)subList->data[i]));
                LOG_ERROR("数组表测试", "获取子列表", "子列表元素验证失败，索引%d，期望值: %d, 实际值: %d", 
                         i, (i + 3) * 10, *((int *)subList->data[i]));
                success = false;
                break;
            }
        }
        
        // 释放子列表
        arrayListDestroy(subList);
    }
    
    // 测试边界情况：从开头到中间
    subList = sourceList->subList(sourceList, 0, 5);
    if (subList != NULL) {
        if (subList->size != 5) {
            printf("[ERROR] 从开头到中间的子列表大小错误\n");
            LOG_ERROR("数组表测试", "获取子列表", "从开头到中间的子列表大小错误");
            success = false;
        }
        arrayListDestroy(subList);
    }
    
    // 测试边界情况：从中间到末尾
    subList = sourceList->subList(sourceList, 5, 10);
    if (subList != NULL) {
        if (subList->size != 5) {
            printf("[ERROR] 从中间到末尾的子列表大小错误\n");
            LOG_ERROR("数组表测试", "获取子列表", "从中间到末尾的子列表大小错误");
            success = false;
        }
        arrayListDestroy(subList);
    }
    
    // 测试无效参数
    subList = sourceList->subList(sourceList, -1, 5);
    if (subList != NULL) {
        printf("[ERROR] 负索引测试失败\n");
        LOG_ERROR("数组表测试", "获取子列表", "负索引测试失败");
        success = false;
        arrayListDestroy(subList);
    }
    
    subList = sourceList->subList(sourceList, 5, 15);
    if (subList != NULL) {
        printf("[ERROR] 超出范围索引测试失败\n");
        LOG_ERROR("数组表测试", "获取子列表", "超出范围索引测试失败");
        success = false;
        arrayListDestroy(subList);
    }
    
    // 释放源数组表
    arrayListDestroy(sourceList);
    
    printf("测试ArrayList subList函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取子列表", "测试ArrayList subList函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList split函数
 */
static bool testArrayListSplit(void) {
    printf("测试ArrayList split函数...\n");
    LOG_INFO("数组表测试", "split函数", "测试ArrayList split函数...");
    
    bool success = true;
    
    // 创建测试数据
    ArrayList *list = arrayListInit(10);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "split函数", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    for (int i = 0; i < 10; i++) {
        int *data = createInt(i);
        list->add(list, data);
    }
    
    // 测试正常分割（索引5）
    //printf("\n测试正常分割（索引5）...\n");
    ArrayList **result = list->split(list, 5);
    if (result == NULL || result[0] == NULL || result[1] == NULL) {
        printf("[ERROR] split返回结果无效\n");
        LOG_ERROR("数组表测试", "split函数", "split返回结果无效");
        success = false;
    } else {
        // 验证第一个子列表（原列表）
        if (result[0]->size != 5) {
            printf("[ERROR] 第一个子列表大小错误: %d, 期望: 5\n", result[0]->size);
            LOG_ERROR("数组表测试", "split函数", "第一个子列表大小错误: %d, 期望: 5", result[0]->size);
            success = false;
        }
        
        // 验证第一个子列表内容
        for (int i = 0; i < 5; i++) {
            int *value = (int *)result[0]->get(result[0], i);
            if (*value != i) {
                printf("[ERROR] 第一个子列表内容错误，索引%d值为%d，期望%d\n", i, *value, i);
                LOG_ERROR("数组表测试", "split函数", "第一个子列表内容错误，索引%d值为%d，期望%d", i, *value, i);
                success = false;
            }
        }
        
        // 验证第二个子列表
        if (result[1]->size != 5) {
            printf("[ERROR] 第二个子列表大小错误: %d, 期望: 5\n", result[1]->size);
            LOG_ERROR("数组表测试", "split函数", "第二个子列表大小错误: %d, 期望: 5", result[1]->size);
            success = false;
        }
        
        // 验证第二个子列表内容
        for (int i = 0; i < 5; i++) {
            int *value = (int *)result[1]->get(result[1], i);
            if (*value != i + 5) {
                printf("[ERROR] 第二个子列表内容错误，索引%d值为%d，期望%d\n", i, *value, i + 5);
                LOG_ERROR("数组表测试", "split函数", "第二个子列表内容错误，索引%d值为%d，期望%d", i, *value, i + 5);
                success = false;
            }
        }
        
        // 释放结果
        free(result[1]->data);
        free(result[1]);
        free(result);
    }
    
    // 重置测试环境
    arrayListDestroy(list);
    list = arrayListInit(10);
    for (int i = 0; i < 10; i++) {
        int *data = createInt(i);
        list->add(list, data);
    }
    
    // 测试边界情况：索引0
    //printf("\n测试边界情况：索引0...\n");
    result = list->split(list, 0);
    if (result != NULL) {
        if (result[0]->size != 0) {
            printf("[ERROR] 索引0分割后原列表大小应为0，实际为%d\n", result[0]->size);
            LOG_ERROR("数组表测试", "split函数", "索引0分割后原列表大小应为0，实际为%d", result[0]->size);
            success = false;
        }
        
        if (result[1]->size != 10) {
            printf("[ERROR] 索引0分割后新列表大小应为10，实际为%d\n", result[1]->size);
            LOG_ERROR("数组表测试", "split函数", "索引0分割后新列表大小应为10，实际为%d", result[1]->size);
            success = false;
        }
        
        free(result[1]->data);
        free(result[1]);
        free(result);
    } else {
        printf("[ERROR] 索引0分割失败\n");
        LOG_ERROR("数组表测试", "split函数", "索引0分割失败");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList split函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "split函数", "测试ArrayList split函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList group函数
 */
static bool testArrayListGroup(void) {
    printf("测试ArrayList group函数...\n");
    LOG_INFO("数组表测试", "group函数", "测试ArrayList group函数...");
    
    bool success = true;
    
    // 创建测试数据
    ArrayList *list = arrayListInit(10);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "group函数", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    for (int i = 0; i < 10; i++) {
        int *data = createInt(i);
        list->add(list, data);
    }
    
    // 执行分组
    ArrayList **groups = list->group(list, groupByEvenOdd);
    if (groups == NULL || groups[0] == NULL || groups[1] == NULL) {
        printf("[ERROR] group返回结果无效\n");
        LOG_ERROR("数组表测试", "group函数", "group返回结果无效");
        success = false;
    } else {
        // 验证分组结果
        if (groups[0]->size != 5 || groups[1]->size != 5) {
            printf("[ERROR] 分组大小错误，偶数组:%d，奇数组:%d，期望都是5\n", 
                   groups[0]->size, groups[1]->size);
            LOG_ERROR("数组表测试", "group函数", "分组大小错误，偶数组:%d，奇数组:%d，期望都是5", 
                     groups[0]->size, groups[1]->size);
            success = false;
        }
        
        // 验证偶数组成员都是偶数
        for (int i = 0; i < groups[0]->size; i++) {
            int *value = (int *)groups[0]->get(groups[0], i);
            if (*value % 2 != 0) {
                printf("[ERROR] 偶数组包含非偶数：%d\n", *value);
                LOG_ERROR("数组表测试", "group函数", "偶数组包含非偶数：%d", *value);
                success = false;
            }
        }
        
        // 验证奇数组成员都是奇数
        for (int i = 0; i < groups[1]->size; i++) {
            int *value = (int *)groups[1]->get(groups[1], i);
            if (*value % 2 != 1) {
                printf("[ERROR] 奇数组包含非奇数：%d\n", *value);
                LOG_ERROR("数组表测试", "group函数", "奇数组包含非奇数：%d", *value);
                success = false;
            }
        }
        
        // 释放分组结果
        free(groups[0]->data);
        free(groups[0]);
        free(groups[1]->data);
        free(groups[1]);
        free(groups);
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList group函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "group函数", "测试ArrayList group函数 %s", success ? "通过" : "失败");
    return success;
}

// 列表操作

/**
 * 测试ArrayList转换为字符串
 */
static bool testArrayListToString(void) {
    printf("测试ArrayList toString函数...\n");
    LOG_INFO("数组表测试", "转换字符串", "测试ArrayList toString函数...");
    
    bool allTestsPassed = true;
    
    // 测试场景1: 空列表测试
    ArrayList *emptyList = arrayListInit(5);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空列表失败\n");
        LOG_ERROR("数组表测试", "转换字符串", "创建空列表失败");
        allTestsPassed = false;
    } else {
        char *str1 = emptyList->toString(emptyList);
        if (str1 == NULL || strcmp(str1, "[]") != 0) {
            printf("[ERROR] 空列表测试失败，预期'[]'，实际'%s'\n", str1 ? str1 : "NULL");
            LOG_ERROR("数组表测试", "转换字符串", "空列表测试失败，预期'[]'，实际'%s'", str1 ? str1 : "NULL");
            allTestsPassed = false;
        }
        free(str1);
        arrayListDestroy(emptyList);
    }
    
    // 测试场景2: 验证字符串格式（检查是否以'['开头，以']'结尾）
    ArrayList *list = arrayListInit(3);
    if (list == NULL) {
        printf("[ERROR] 创建列表失败\n");
        LOG_ERROR("数组表测试", "转换字符串", "创建列表失败");
        allTestsPassed = false;
    } else {
        // 为了测试，我们直接设置size和添加一些元素到data数组
        // 注意：在实际使用中应该通过add方法添加元素
        int *value1 = (int *)malloc(sizeof(int));
        int *value2 = (int *)malloc(sizeof(int));
        if (value1 != NULL && value2 != NULL) {
            *value1 = 10;
            *value2 = 20;
            
            list->data[0] = value1;
            list->data[1] = value2;
            list->size = 2;
            
            char *str2 = list->toString(list);
            if (str2 == NULL) {
                printf("[ERROR] toString返回NULL\n");
                LOG_ERROR("数组表测试", "转换字符串", "toString返回NULL");
                allTestsPassed = false;
            } else {
                // 检查字符串格式是否正确
                int len = strlen(str2);
                if (str2[0] != '[' || str2[len - 1] != ']') {
                    printf("[ERROR] 字符串格式错误，应该以'['开头，以']'结尾，实际'%s'\n", str2);
                    LOG_ERROR("数组表测试", "转换字符串", "字符串格式错误，应该以'['开头，以']'结尾，实际'%s'", str2);
                    allTestsPassed = false;
                }
                free(str2);
            }
        }
        
        // 释放资源
        free(value1);
        free(value2);
        arrayListDestroy(list);
    }
    
    printf("测试ArrayList toString函数 %s\n", allTestsPassed ? "通过" : "失败");
    LOG_INFO("数组表测试", "转换字符串", "测试ArrayList toString函数 %s", allTestsPassed ? "通过" : "失败");
    return allTestsPassed;
}

/**
 * 测试ArrayList hashCode函数
 */
static bool testArrayListHashCode(void) {
    printf("测试ArrayList hashCode函数...\n");
    LOG_INFO("数组表测试", "获取哈希值", "开始测试ArrayList hashCode函数");
    
    bool success = true;
    
    // 创建并初始化两个相同内容的ArrayList
    ArrayList *list1 = arrayListInit(5);
    ArrayList *list2 = arrayListInit(5);
    
    // 添加相同的元素
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    
    list1->add(list1, data1);
    list1->add(list1, data2);
    
    // 由于哈希值基于指针地址，这里我们只验证哈希值计算不会导致崩溃
    int hashCode1 = list1->hashCode(list1);
    int hashCode2 = list2->hashCode(list2);
    
    // 验证哈希值不是-1（错误值）
    if (hashCode1 == -1 || hashCode2 == -1) {
        printf("哈希值计算错误，返回了-1\n");
        success = false;
    }
    
    printf("list1哈希值: %d, list2哈希值: %d\n", hashCode1, hashCode2);
    
    // 释放内存
    arrayListDestroy(list1);
    arrayListDestroy(list2);
    freeIntData(data1);
    freeIntData(data2);
    
    printf("测试ArrayList hashCode函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取哈希值", "测试ArrayList hashCode函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList isEmpty函数
 */
static bool testArrayListIsEmpty(void) {
    printf("测试ArrayList isEmpty函数...\n");
    LOG_INFO("数组表测试", "判断是否为空", "开始测试ArrayList isEmpty函数");
    
    bool success = true;
    
    // 创建并初始化空ArrayList
    ArrayList *list = arrayListInit(5);
    
    // 验证空数组表isEmpty返回true
    if (!list->isEmpty(list)) {
        printf("空数组表isEmpty应返回true，但返回false\n");
        success = false;
    }
    
    // 添加元素后验证isEmpty返回false
    int *data = createInt(100);
    list->add(list, data);
    
    if (list->isEmpty(list)) {
        printf("非空数组表isEmpty应返回false，但返回true\n");
        success = false;
    }
    
    // 清空后验证isEmpty返回true
    list->clear(list);
    if (!list->isEmpty(list)) {
        printf("清空后isEmpty应返回true，但返回false\n");
        success = false;
    }
    
    // 释放内存
    arrayListDestroy(list);
    freeIntData(data);
    
    printf("测试ArrayList isEmpty函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "判断是否为空", "测试ArrayList isEmpty函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList addAllIndex函数
 */
static bool testArrayListAddAllIndex(void) {
    printf("测试ArrayList addAllIndex函数...\n");
    LOG_INFO("数组表测试", "指定位置批量添加", "测试ArrayList addAllIndex函数...");
    
    bool success = true;
    
    // 创建源数组表
    ArrayList *sourceList = arrayListInit(5);
    int *s1 = createInt(100);
    int *s2 = createInt(200);
    int *s3 = createInt(300);
    sourceList->add(sourceList, s1);
    sourceList->add(sourceList, s2);
    sourceList->add(sourceList, s3);
    
    // 创建目标数组表
    ArrayList *targetList = arrayListInit(5);
    int *t1 = createInt(10);
    int *t2 = createInt(20);
    int *t3 = createInt(30);
    targetList->add(targetList, t1);
    targetList->add(targetList, t2);
    targetList->add(targetList, t3);
    
    // 测试在中间位置添加
    bool result = targetList->addAllIndex(targetList, 1, sourceList);
    if (!result || targetList->size != 6) {
        printf("[ERROR] 在中间位置添加元素失败，size=%d\n", targetList->size);
        LOG_ERROR("数组表测试", "指定位置批量添加", "在中间位置添加元素失败，size=%d", targetList->size);
        success = false;
    }
    
    // 验证元素顺序
    if (*((int *)targetList->data[0]) != 10 || 
        *((int *)targetList->data[1]) != 100 || 
        *((int *)targetList->data[2]) != 200 || 
        *((int *)targetList->data[3]) != 300 || 
        *((int *)targetList->data[4]) != 20 || 
        *((int *)targetList->data[5]) != 30) {
        printf("[ERROR] 元素顺序验证失败\n");
        LOG_ERROR("数组表测试", "指定位置批量添加", "元素顺序验证失败");
        success = false;
    }
    
    // 测试在头部添加
    ArrayList *newSource = arrayListInit(2);
    int *ns1 = createInt(1);
    int *ns2 = createInt(2);
    newSource->add(newSource, ns1);
    newSource->add(newSource, ns2);
    
    result = targetList->addAllIndex(targetList, 0, newSource);
    if (!result || targetList->size != 8) {
        printf("[ERROR] 在头部添加元素失败，size=%d\n", targetList->size);
        LOG_ERROR("数组表测试", "指定位置批量添加", "在头部添加元素失败，size=%d", targetList->size);
        success = false;
    }
    
    // 测试在尾部添加
    int *ns3 = createInt(3);
    newSource->add(newSource, ns3);
    result = targetList->addAllIndex(targetList, targetList->size, newSource);
    if (!result || targetList->size != 11) {
        printf("[ERROR] 在尾部添加元素失败，size=%d\n", targetList->size);
        LOG_ERROR("数组表测试", "指定位置批量添加", "在尾部添加元素失败，size=%d", targetList->size);
        success = false;
    }
    
    // 测试参数错误情况
    result = targetList->addAllIndex(NULL, 0, sourceList);
    if (result) {
        printf("[ERROR] 空指针参数测试失败\n");
        LOG_ERROR("数组表测试", "指定位置批量添加", "空指针参数测试失败");
        success = false;
    }
    
    result = targetList->addAllIndex(targetList, -1, sourceList);
    if (result) {
        printf("[ERROR] 负索引参数测试失败\n");
        LOG_ERROR("数组表测试", "指定位置批量添加", "负索引参数测试失败");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(sourceList);
    arrayListDestroy(targetList);
    arrayListDestroy(newSource);
    // 注意：因为在测试中元素已经通过ArrayList的destroy方法释放，所以不需要在这里单独释放
    
    printf("测试ArrayList addAllIndex函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "指定位置批量添加", "测试ArrayList addAllIndex函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的removeRange函数
 */
static bool testArrayListRemoveRange() {
    printf("测试ArrayList removeRange函数...\n");
    LOG_INFO("数组表测试", "删除指定范围元素", "测试ArrayList removeRange函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "删除指定范围元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    int *data5 = createInt(50);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL || data5 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "删除指定范围元素", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    list->add(list, data4);
    list->add(list, data5);
    
    bool success = true;
    
    // 测试删除中间范围元素
    list->removeRange(list, 1, 3);
    if (list->size != 3) {
        printf("[ERROR] 删除中间范围元素失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "删除指定范围元素", "删除中间范围元素失败，size=%d", list->size);
        success = false;
    }
    
    // 验证元素内容和顺序
    if (*((int *)list->data[0]) != 10 || *((int *)list->data[1]) != 40 || *((int *)list->data[2]) != 50) {
        printf("[ERROR] 删除中间范围元素后，元素内容或顺序不正确\n");
        LOG_ERROR("数组表测试", "删除指定范围元素", "删除中间范围元素后，元素内容或顺序不正确");
        success = false;
    }
    
    // 测试边界情况：fromIndex大于toIndex - removeRange返回void，所以直接调用检查结果
    int originalSize = list->size;
    list->removeRange(list, 3, 1);
    if (list->size != originalSize) {
        printf("[ERROR] fromIndex大于toIndex应该返回false\n");
        LOG_ERROR("数组表测试", "删除指定范围元素", "fromIndex大于toIndex应该返回false");
        success = false;
    }
    
    // 测试边界情况：索引越界
    originalSize = list->size;
    list->removeRange(list, 0, 10);
    if (list->size != originalSize) {
        printf("[ERROR] toIndex越界应该返回false\n");
        LOG_ERROR("数组表测试", "删除指定范围元素", "toIndex越界应该返回false");
        success = false;
    }
    
    // 测试边界情况：负数索引
    originalSize = list->size;
    list->removeRange(list, -1, 2);
    if (list->size != originalSize) {
        printf("[ERROR] 负数索引应该返回false\n");
        LOG_ERROR("数组表测试", "删除指定范围元素", "负数索引应该返回false");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList removeRange函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "删除指定范围元素", "测试ArrayList removeRange函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList truncate函数
 */
static bool testArrayListTruncate(void) {
    printf("测试ArrayList truncate函数...\n");
    LOG_INFO("数组表测试", "截断数组表", "测试ArrayList truncate函数...");
    
    bool success = true;
    
    // 创建数组表
    ArrayList *list = arrayListInit(10);
    for (int i = 1; i <= 8; i++) {
        int *data = createInt(i * 10);
        list->add(list, data);
    }
    
    int originalCapacity = list->capacity;
    
    // 测试截断到更小的大小
    bool result = list->truncate(list, 5);
    if (!result || list->size != 5) {
        printf("[ERROR] 截断到更小的大小失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "截断数组表", "截断到更小的大小失败，size=%d", list->size);
        success = false;
    }
    
    // 验证容量没有改变
    if (list->capacity != originalCapacity) {
        printf("[ERROR] 截断后容量改变，期望值: %d, 实际值: %d\n", originalCapacity, list->capacity);
        LOG_ERROR("数组表测试", "截断数组表", "截断后容量改变，期望值: %d, 实际值: %d", originalCapacity, list->capacity);
        success = false;
    }
    
    // 测试扩展到更大但不超过容量的大小
    result = list->truncate(list, 8);
    if (!result || list->size != 8) {
        printf("[ERROR] 扩展到更大但不超过容量的大小失败，size=%d\n", list->size);
        LOG_ERROR("数组表测试", "截断数组表", "扩展到更大但不超过容量的大小失败，size=%d", list->size);
        success = false;
    }
    
    // 测试无效参数
    result = list->truncate(list, -1);
    if (result) {
        printf("[ERROR] 负大小测试失败\n");
        LOG_ERROR("数组表测试", "截断数组表", "负大小测试失败");
        success = false;
    }
    
    // 测试超过容量的大小
    result = list->truncate(list, list->capacity + 1);
    if (result) {
        printf("[ERROR] 超过容量的大小测试失败\n");
        LOG_ERROR("数组表测试", "截断数组表", "超过容量的大小测试失败");
        success = false;
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList truncate函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "截断数组表", "测试ArrayList truncate函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList clear函数
 */
static bool testArrayListClear(void) {
    printf("测试ArrayList clear函数...\n");
    LOG_INFO("数组表测试", "清空操作", "开始测试ArrayList clear函数");
    
    bool success = true;
    
    // 创建测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    // 创建并初始化ArrayList
    ArrayList *list = arrayListInit(10);
    
    // 添加元素
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    // 验证清空前的大小
    if (list->getSize(list) != 3) {
        printf("清空前数组表大小错误，期望值: 3, 实际值: %d\n", list->getSize(list));
        success = false;
    }
    
    // 执行清空操作
    list->clear(list);
    
    // 验证清空后的大小
    if (list->getSize(list) != 0) {
        printf("清空后数组表大小错误，期望值: 0, 实际值: %d\n", list->getSize(list));
        success = false;
    }
    
    // 验证isEmpty返回true
    if (!list->isEmpty(list)) {
        printf("清空后isEmpty应返回true，但返回false\n");
        success = false;
    }
    
    // 释放内存
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    
    printf("测试ArrayList clear函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "清空操作", "测试ArrayList clear函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的forEach函数
 */
static bool testArrayListForEach(void) {
    printf("测试ArrayList forEach函数...\n");
    LOG_INFO("数组表测试", "正序遍历元素", "测试ArrayList forEach函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "正序遍历元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "正序遍历元素", "创建测试数据失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    // 用于记录遍历顺序的数组
    int visitedOrder[3] = {0};
    int *orderPtr = visitedOrder;
    
    // 定义访问函数：记录访问顺序并将元素值加1
    void visitAndIncrement(void *element) {
        *orderPtr++ = *((int *)element);
        *((int *)element) += 1;
    }
    
    // 执行遍历操作
    list->forEach(list, visitAndIncrement);
    
    bool success = true;
    
    // 验证遍历顺序
    if (visitedOrder[0] != 10 || visitedOrder[1] != 20 || visitedOrder[2] != 30) {
        printf("[ERROR] 遍历顺序不正确\n");
        LOG_ERROR("数组表测试", "正序遍历元素", "遍历顺序测试失败");
        success = false;
    }
    
    // 验证元素被正确修改
    if (*((int *)list->data[0]) != 11 || *((int *)list->data[1]) != 21 || *((int *)list->data[2]) != 31) {
        printf("[ERROR] 元素没有被正确修改\n");
        LOG_ERROR("数组表测试", "正序遍历元素", "元素修改测试失败");
        success = false;
    }
    
    // 测试空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "正序遍历元素", "创建空ArrayList失败");
        success = false;
    } else {
        emptyList->forEach(emptyList, visitAndIncrement);
        // 空列表应该没有变化
        if (emptyList->size != 0) {
            printf("[ERROR] 空列表遍历后大小应该为0\n");
            LOG_ERROR("数组表测试", "正序遍历元素", "空列表遍历测试失败");
            success = false;
        }
        arrayListDestroy(emptyList);
    }
    
    // 释放资源
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    
    printf("测试ArrayList forEach函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "正序遍历元素", "测试ArrayList forEach函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的forEachReverse函数
 */
static bool testArrayListForEachReverse(void) {
    printf("测试ArrayList forEachReverse函数...\n");
    LOG_INFO("数组表测试", "逆序遍历元素", "测试ArrayList forEachReverse函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "逆序遍历元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "逆序遍历元素", "创建测试数据失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    
    // 用于记录遍历顺序的数组
    int visitedOrder[3] = {0};
    int *orderPtr = visitedOrder;
    
    // 定义访问函数：记录访问顺序并将元素值减1
    void visitAndDecrement(void *element) {
        *orderPtr++ = *((int *)element);
        *((int *)element) -= 1;
    }
    
    // 执行逆序遍历操作
    list->forEachReverse(list, visitAndDecrement);
    
    bool success = true;
    
    // 验证遍历顺序（应该是30, 20, 10）
    if (visitedOrder[0] != 30 || visitedOrder[1] != 20 || visitedOrder[2] != 10) {
        printf("[ERROR] 逆序遍历顺序不正确\n");
        LOG_ERROR("数组表测试", "逆序遍历元素", "逆序遍历顺序测试失败");
        success = false;
    }
    
    // 验证元素被正确修改
    if (*((int *)list->data[0]) != 9 || *((int *)list->data[1]) != 19 || *((int *)list->data[2]) != 29) {
        printf("[ERROR] 元素没有被正确修改\n");
        LOG_ERROR("数组表测试", "逆序遍历元素", "元素修改测试失败");
        success = false;
    }
    
    // 测试空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "逆序遍历元素", "创建空ArrayList失败");
        success = false;
    } else {
        emptyList->forEachReverse(emptyList, visitAndDecrement);
        // 空列表应该没有变化
        if (emptyList->size != 0) {
            printf("[ERROR] 空列表遍历后大小应该为0\n");
            LOG_ERROR("数组表测试", "逆序遍历元素", "空列表遍历测试失败");
            success = false;
        }
        arrayListDestroy(emptyList);
    }
    
    // 释放资源
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    
    printf("测试ArrayList forEachReverse函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "逆序遍历元素", "测试ArrayList forEachReverse函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList的reverse函数
 */
static bool testArrayListReverse(void) {
    printf("测试ArrayList reverse函数...\n");
    LOG_INFO("数组表测试", "反转元素", "测试ArrayList reverse函数...");
    
    // 创建ArrayList并添加元素
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "反转元素", "创建ArrayList失败");
        return false;
    }
    
    // 添加测试数据
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    int *data4 = createInt(40);
    
    if (data1 == NULL || data2 == NULL || data3 == NULL || data4 == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "反转元素", "创建测试数据失败");
        arrayListDestroy(list);
        freeIntData(data1);
        freeIntData(data2);
        freeIntData(data3);
        freeIntData(data4);
        return false;
    }
    
    list->add(list, data1);
    list->add(list, data2);
    list->add(list, data3);
    list->add(list, data4);
    
    // 执行反转操作
    list->reverse(list);
    
    bool success = true;
    
    // 验证反转后的顺序（应该是40, 30, 20, 10）
    if (*((int *)list->data[0]) != 40 || *((int *)list->data[1]) != 30 || 
        *((int *)list->data[2]) != 20 || *((int *)list->data[3]) != 10) {
        printf("[ERROR] 反转后的元素顺序不正确\n");
        LOG_ERROR("数组表测试", "反转元素", "元素反转测试失败");
        success = false;
    }
    
    // 再次反转，应该恢复原顺序
    list->reverse(list);
    if (*((int *)list->data[0]) != 10 || *((int *)list->data[1]) != 20 || 
        *((int *)list->data[2]) != 30 || *((int *)list->data[3]) != 40) {
        printf("[ERROR] 再次反转后没有恢复原顺序\n");
        LOG_ERROR("数组表测试", "反转元素", "二次反转测试失败");
        success = false;
    }
    
    // 测试空列表
    ArrayList *emptyList = arrayListInit(0);
    if (emptyList == NULL) {
        printf("[ERROR] 创建空ArrayList失败\n");
        LOG_ERROR("数组表测试", "反转元素", "创建空ArrayList失败");
        success = false;
    } else {
        emptyList->reverse(emptyList);
        // 空列表应该没有变化
        if (emptyList->size != 0) {
            printf("[ERROR] 空列表反转后大小应该为0\n");
            LOG_ERROR("数组表测试", "反转元素", "空列表反转测试失败");
            success = false;
        }
        arrayListDestroy(emptyList);
    }
    
    // 测试只有一个元素的列表
    ArrayList *singleElementList = arrayListInit(1);
    int *singleData = createInt(50);
    if (singleElementList == NULL || singleData == NULL) {
        printf("[ERROR] 创建单元素列表失败\n");
        LOG_ERROR("数组表测试", "反转元素", "创建单元素列表失败");
        success = false;
    } else {
        singleElementList->add(singleElementList, singleData);
        singleElementList->reverse(singleElementList);
        // 单元素列表反转后应该不变
        if (*((int *)singleElementList->data[0]) != 50 || singleElementList->size != 1) {
            printf("[ERROR] 单元素列表反转后应该不变\n");
            LOG_ERROR("数组表测试", "反转元素", "单元素列表反转测试失败");
            success = false;
        }
        arrayListDestroy(singleElementList);
        freeIntData(singleData);
    }
    
    // 释放资源
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    freeIntData(data4);
    
    printf("测试ArrayList reverse函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "反转元素", "测试ArrayList reverse函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList sort函数
 */
static bool testArrayListSort(void) {
    printf("测试ArrayList sort函数...\n");
    LOG_INFO("数组表测试", "sort函数", "测试ArrayList sort函数...");
    
    bool success = true;
    
    // 创建测试数据
    ArrayList *list = arrayListInit(10);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "sort函数", "创建ArrayList失败");
        return false;
    }
    
    // 添加乱序测试数据
    int values[] = {5, 3, 8, 1, 9, 2, 7, 4, 6, 0};
    for (int i = 0; i < 10; i++) {
        int *data = createInt(values[i]);
        list->add(list, data);
    }
    
    // 测试升序排序
    // printf("\n测试升序排序...\n");
    list->sort(list, 0, compareInt);
    
    // 验证排序结果
    for (int i = 0; i < 10; i++) {
        int *value = (int *)list->get(list, i);
        if (*value != i) {
            printf("[ERROR] 升序排序失败，索引%d值为%d，期望%d\n", i, *value, i);
            LOG_ERROR("数组表测试", "sort函数", "升序排序失败，索引%d值为%d，期望%d", i, *value, i);
            success = false;
            break;
        }
    }
    
    // 重置测试环境
    arrayListDestroy(list);
    list = arrayListInit(10);
    for (int i = 0; i < 10; i++) {
        int *data = createInt(values[i]);
        list->add(list, data);
    }
    
    // 测试降序排序
    // printf("\n测试降序排序...\n");
    list->sort(list, 1, compareInt);
    
    // 验证降序排序结果
    for (int i = 0; i < 10; i++) {
        int *value = (int *)list->get(list, i);
        if (*value != 9 - i) {
            printf("[ERROR] 降序排序失败，索引%d值为%d，期望%d\n", i, *value, 9 - i);
            LOG_ERROR("数组表测试", "sort函数", "降序排序失败，索引%d值为%d，期望%d", i, *value, 9 - i);
            success = false;
            break;
        }
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList sort函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "sort函数", "测试ArrayList sort函数 %s", success ? "通过" : "失败");
    return success;
}

// 属性操作

/**
 * 测试ArrayList getSize函数
 */
static bool testArrayListGetSize(void) {
    printf("测试ArrayList getSize函数...\n");
    LOG_INFO("数组表测试", "获取大小", "开始测试ArrayList getSize函数");
    
    bool success = true;
    
    // 创建并初始化ArrayList
    ArrayList *list = arrayListInit(5);
    
    // 验证初始大小为0
    if (list->getSize(list) != 0) {
        printf("初始数组表大小错误，期望值: 0, 实际值: %d\n", list->getSize(list));
        success = false;
    }
    
    // 添加元素并验证大小
    int *data1 = createInt(10);
    int *data2 = createInt(20);
    int *data3 = createInt(30);
    
    list->add(list, data1);
    if (list->getSize(list) != 1) {
        printf("添加1个元素后大小错误，期望值: 1, 实际值: %d\n", list->getSize(list));
        success = false;
    }
    
    list->add(list, data2);
    if (list->getSize(list) != 2) {
        printf("添加2个元素后大小错误，期望值: 2, 实际值: %d\n", list->getSize(list));
        success = false;
    }
    
    list->add(list, data3);
    if (list->getSize(list) != 3) {
        printf("添加3个元素后大小错误，期望值: 3, 实际值: %d\n", list->getSize(list));
        success = false;
    }
    
    // 清空后验证大小为0
    list->clear(list);
    if (list->getSize(list) != 0) {
        printf("清空后大小错误，期望值: 0, 实际值: %d\n", list->getSize(list));
        success = false;
    }
    
    // 释放内存
    arrayListDestroy(list);
    freeIntData(data1);
    freeIntData(data2);
    freeIntData(data3);
    
    printf("测试ArrayList getSize函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取大小", "测试ArrayList getSize函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList getCapacity函数
 */
static bool testArrayListGetCapacity(void) {
    printf("测试ArrayList getCapacity函数...\n");
    LOG_INFO("数组表测试", "获取容量", "开始测试ArrayList getCapacity函数");
    
    bool success = true;
    
    // 测试不同初始容量
    int capacities[] = {5, 10, 20};
    
    for (int i = 0; i < 3; i++) {
        int expectedCapacity = capacities[i];
        ArrayList *list = arrayListInit(expectedCapacity);
        
        int actualCapacity = list->getCapacity(list);
        if (actualCapacity != expectedCapacity) {
            printf("容量错误，期望值: %d, 实际值: %d\n", expectedCapacity, actualCapacity);
            success = false;
        }
        
        // 释放内存
        arrayListDestroy(list);
    }
    
    // 测试添加元素后容量不变（在需要扩容前）
    ArrayList *list = arrayListInit(10);
    int initialCapacity = list->getCapacity(list);
    
    // 添加一些元素但不触发扩容
    for (int i = 0; i < 5; i++) {
        int *data = createInt(i);
        list->add(list, data);
        freeIntData(data); // 我们只是测试容量，这里可以直接释放数据
    }
    
    int afterAddCapacity = list->getCapacity(list);
    if (afterAddCapacity != initialCapacity) {
        printf("添加元素后容量不应改变，初始: %d, 添加后: %d\n", initialCapacity, afterAddCapacity);
        success = false;
    }
    
    // 释放内存
    arrayListDestroy(list);
    
    printf("测试ArrayList getCapacity函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "获取容量", "测试ArrayList getCapacity函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 测试ArrayList ensureCapacity函数
 */
static bool testArrayListEnsureCapacity(void) {
    printf("测试ArrayList ensureCapacity函数...\n");
    LOG_INFO("数组表测试", "确保容量", "测试ArrayList ensureCapacity函数...");
    
    // 创建ArrayList
    ArrayList *list = arrayListInit(5);
    if (list == NULL) {
        printf("[ERROR] 创建ArrayList失败\n");
        LOG_ERROR("数组表测试", "确保容量", "创建ArrayList失败");
        return false;
    }
    
    bool success = true;
    
    // 测试场景1：当前容量已经足够大
    bool result = list->ensureCapacity(list, 3);
    if (!result || list->capacity != 5) {
        printf("[ERROR] 当前容量已足够时，ensureCapacity应该返回true且不改变容量\n");
        LOG_ERROR("数组表测试", "确保容量", "当前容量已足够时测试失败");
        success = false;
    }
    
    // 测试场景2：需要扩容
    result = list->ensureCapacity(list, 10);
    if (!result || list->capacity < 10) {
        printf("[ERROR] 扩容测试失败，新容量应为至少10，实际为%d\n", list->capacity);
        LOG_ERROR("数组表测试", "确保容量", "扩容测试失败");
        success = false;
    }
    
    // 测试场景3：扩容因子计算的容量小于minCapacity，应使用minCapacity
    int currentCapacity = list->capacity;
    int largeMinCapacity = currentCapacity * 2 + 1; // 确保大于扩容因子计算的容量
    result = list->ensureCapacity(list, largeMinCapacity);
    if (!result || list->capacity < largeMinCapacity) {
        printf("[ERROR] 使用minCapacity作为新容量测试失败，新容量应为至少%d，实际为%d\n", 
               largeMinCapacity, list->capacity);
        LOG_ERROR("数组表测试", "确保容量", "使用minCapacity作为新容量测试失败");
        success = false;
    }
    
    // 测试场景4：边界情况 - 参数为NULL
    result = list->ensureCapacity(NULL, 10);
    if (result) {
        printf("[ERROR] 参数为NULL时，ensureCapacity应该返回false\n");
        LOG_ERROR("数组表测试", "确保容量", "NULL参数测试失败");
        success = false;
    }
    
    // 测试场景5：最小容量为0
    result = list->ensureCapacity(list, 0);
    if (!result) {
        printf("[ERROR] minCapacity为0时，ensureCapacity应该返回true\n");
        LOG_ERROR("数组表测试", "确保容量", "minCapacity为0测试失败");
        success = false;
    }
    
    // 测试场景6：扩容后添加元素仍然有效
    int *data = createInt(100);
    if (data == NULL) {
        printf("[ERROR] 创建测试数据失败\n");
        LOG_ERROR("数组表测试", "确保容量", "创建测试数据失败");
        arrayListDestroy(list);
        return false;
    }
    
    result = list->add(list, data);
    if (!result) {
        printf("[ERROR] 扩容后添加元素失败\n");
        LOG_ERROR("数组表测试", "确保容量", "扩容后添加元素失败");
        success = false;
        freeIntData(data);
    }
    
    // 释放资源
    arrayListDestroy(list);
    
    printf("测试ArrayList ensureCapacity函数 %s\n", success ? "通过" : "失败");
    LOG_INFO("数组表测试", "确保容量", "测试ArrayList ensureCapacity函数 %s", success ? "通过" : "失败");
    return success;
}

/**
 * 执行ArrayList的单元测试
 */
bool arrayListUnitTest(void) {
    bool allTestsPassed = true;
    
    // 按顺序执行各个测试用例
    // 初始化
    allTestsPassed &= testArrayListInit();
    // 数据操作
    allTestsPassed &= testArrayListAdd();
    allTestsPassed &= testArrayListRemove();
    allTestsPassed &= testArrayListContains();
    allTestsPassed &= testArrayListIndexOf();
    allTestsPassed &= testArrayListLastIndexOf();
    allTestsPassed &= testArrayListReplaceAll();
    // 索引操作
    allTestsPassed &= testArrayListAddIndex();
    allTestsPassed &= testArrayListAddFirstAndAddLast();
    allTestsPassed &= testArrayListRemoveIndex();
    allTestsPassed &= testArrayListRemoveFirst();
    allTestsPassed &= testArrayListRemoveLast();
    allTestsPassed &= testArrayListSet();
    allTestsPassed &= testArrayListSetFirst();
    allTestsPassed &= testArrayListSetLast();
    allTestsPassed &= testArrayListGet();
    allTestsPassed &= testArrayListGetFirst();
    allTestsPassed &= testArrayListGetLast();
    // 集合操作
    allTestsPassed &= testArrayListAddAll();
    allTestsPassed &= testArrayListRemoveAll();
    allTestsPassed &= testArrayListRetainAll();
    allTestsPassed &= testArrayListContainsAll();
    allTestsPassed &= testArrayListMerge();
    allTestsPassed &= testArrayListEquals();
    allTestsPassed &= testArrayListClone();
    allTestsPassed &= testArrayListSubList();
    allTestsPassed &= testArrayListSplit();
    allTestsPassed &= testArrayListGroup();
    // 列表操作
    allTestsPassed &= testArrayListToString();
    allTestsPassed &= testArrayListHashCode();
    allTestsPassed &= testArrayListIsEmpty();
    allTestsPassed &= testArrayListAddAllIndex();
    allTestsPassed &= testArrayListRemoveRange();
    allTestsPassed &= testArrayListTruncate();
    allTestsPassed &= testArrayListClear();
    allTestsPassed &= testArrayListForEach();
    allTestsPassed &= testArrayListForEachReverse();
    allTestsPassed &= testArrayListReverse();
    allTestsPassed &= testArrayListSort();
    // 属性操作
    allTestsPassed &= testArrayListGetSize();
    allTestsPassed &= testArrayListGetCapacity();
    allTestsPassed &= testArrayListEnsureCapacity();
    
    return allTestsPassed;
}
